/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controladores;

import controladores.exceptions.IllegalOrphanException;
import controladores.exceptions.NonexistentEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import entity.ObjetoEntity;
import java.util.ArrayList;
import java.util.Collection;
import entity.ComentarioEntity;
import entity.UsuarioEntity;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author Gaston
 */
public class UsuarioEntityJpaController implements Serializable
{

    public UsuarioEntityJpaController(EntityManagerFactory emf)
    {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager()
    {
        return emf.createEntityManager();
    }

    public void create(UsuarioEntity usuarioEntity)
    {
        if (usuarioEntity.getObjetoEntityCollection() == null)
        {
            usuarioEntity.setObjetoEntityCollection(new ArrayList<ObjetoEntity>());
        }
        if (usuarioEntity.getComentarioEntityCollection() == null)
        {
            usuarioEntity.setComentarioEntityCollection(new ArrayList<ComentarioEntity>());
        }
        EntityManager em = null;
        try
        {
            em = getEntityManager();
            em.getTransaction().begin();
            Collection<ObjetoEntity> attachedObjetoEntityCollection = new ArrayList<ObjetoEntity>();
            for (ObjetoEntity objetoEntityCollectionObjetoEntityToAttach : usuarioEntity.getObjetoEntityCollection())
            {
                objetoEntityCollectionObjetoEntityToAttach = em.getReference(objetoEntityCollectionObjetoEntityToAttach.getClass(), objetoEntityCollectionObjetoEntityToAttach.getId());
                attachedObjetoEntityCollection.add(objetoEntityCollectionObjetoEntityToAttach);
            }
            usuarioEntity.setObjetoEntityCollection(attachedObjetoEntityCollection);
            Collection<ComentarioEntity> attachedComentarioEntityCollection = new ArrayList<ComentarioEntity>();
            for (ComentarioEntity comentarioEntityCollectionComentarioEntityToAttach : usuarioEntity.getComentarioEntityCollection())
            {
                comentarioEntityCollectionComentarioEntityToAttach = em.getReference(comentarioEntityCollectionComentarioEntityToAttach.getClass(), comentarioEntityCollectionComentarioEntityToAttach.getId());
                attachedComentarioEntityCollection.add(comentarioEntityCollectionComentarioEntityToAttach);
            }
            usuarioEntity.setComentarioEntityCollection(attachedComentarioEntityCollection);
            em.persist(usuarioEntity);
            for (ObjetoEntity objetoEntityCollectionObjetoEntity : usuarioEntity.getObjetoEntityCollection())
            {
                UsuarioEntity oldUsuarioOfObjetoEntityCollectionObjetoEntity = objetoEntityCollectionObjetoEntity.getUsuario();
                objetoEntityCollectionObjetoEntity.setUsuario(usuarioEntity);
                objetoEntityCollectionObjetoEntity = em.merge(objetoEntityCollectionObjetoEntity);
                if (oldUsuarioOfObjetoEntityCollectionObjetoEntity != null)
                {
                    oldUsuarioOfObjetoEntityCollectionObjetoEntity.getObjetoEntityCollection().remove(objetoEntityCollectionObjetoEntity);
                    oldUsuarioOfObjetoEntityCollectionObjetoEntity = em.merge(oldUsuarioOfObjetoEntityCollectionObjetoEntity);
                }
            }
            for (ComentarioEntity comentarioEntityCollectionComentarioEntity : usuarioEntity.getComentarioEntityCollection())
            {
                UsuarioEntity oldUsuarioOfComentarioEntityCollectionComentarioEntity = comentarioEntityCollectionComentarioEntity.getUsuario();
                comentarioEntityCollectionComentarioEntity.setUsuario(usuarioEntity);
                comentarioEntityCollectionComentarioEntity = em.merge(comentarioEntityCollectionComentarioEntity);
                if (oldUsuarioOfComentarioEntityCollectionComentarioEntity != null)
                {
                    oldUsuarioOfComentarioEntityCollectionComentarioEntity.getComentarioEntityCollection().remove(comentarioEntityCollectionComentarioEntity);
                    oldUsuarioOfComentarioEntityCollectionComentarioEntity = em.merge(oldUsuarioOfComentarioEntityCollectionComentarioEntity);
                }
            }
            em.getTransaction().commit();
        } finally
        {
            if (em != null)
            {
                em.close();
            }
        }
    }

    public void edit(UsuarioEntity usuarioEntity) throws IllegalOrphanException, NonexistentEntityException, Exception
    {
        EntityManager em = null;
        try
        {
            em = getEntityManager();
            em.getTransaction().begin();
            UsuarioEntity persistentUsuarioEntity = em.find(UsuarioEntity.class, usuarioEntity.getId());
            Collection<ObjetoEntity> objetoEntityCollectionOld = persistentUsuarioEntity.getObjetoEntityCollection();
            Collection<ObjetoEntity> objetoEntityCollectionNew = usuarioEntity.getObjetoEntityCollection();
            Collection<ComentarioEntity> comentarioEntityCollectionOld = persistentUsuarioEntity.getComentarioEntityCollection();
            Collection<ComentarioEntity> comentarioEntityCollectionNew = usuarioEntity.getComentarioEntityCollection();
            List<String> illegalOrphanMessages = null;
            for (ObjetoEntity objetoEntityCollectionOldObjetoEntity : objetoEntityCollectionOld)
            {
                if (!objetoEntityCollectionNew.contains(objetoEntityCollectionOldObjetoEntity))
                {
                    if (illegalOrphanMessages == null)
                    {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ObjetoEntity " + objetoEntityCollectionOldObjetoEntity + " since its usuario field is not nullable.");
                }
            }
            for (ComentarioEntity comentarioEntityCollectionOldComentarioEntity : comentarioEntityCollectionOld)
            {
                if (!comentarioEntityCollectionNew.contains(comentarioEntityCollectionOldComentarioEntity))
                {
                    if (illegalOrphanMessages == null)
                    {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ComentarioEntity " + comentarioEntityCollectionOldComentarioEntity + " since its usuario field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null)
            {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Collection<ObjetoEntity> attachedObjetoEntityCollectionNew = new ArrayList<ObjetoEntity>();
            for (ObjetoEntity objetoEntityCollectionNewObjetoEntityToAttach : objetoEntityCollectionNew)
            {
                objetoEntityCollectionNewObjetoEntityToAttach = em.getReference(objetoEntityCollectionNewObjetoEntityToAttach.getClass(), objetoEntityCollectionNewObjetoEntityToAttach.getId());
                attachedObjetoEntityCollectionNew.add(objetoEntityCollectionNewObjetoEntityToAttach);
            }
            objetoEntityCollectionNew = attachedObjetoEntityCollectionNew;
            usuarioEntity.setObjetoEntityCollection(objetoEntityCollectionNew);
            Collection<ComentarioEntity> attachedComentarioEntityCollectionNew = new ArrayList<ComentarioEntity>();
            for (ComentarioEntity comentarioEntityCollectionNewComentarioEntityToAttach : comentarioEntityCollectionNew)
            {
                comentarioEntityCollectionNewComentarioEntityToAttach = em.getReference(comentarioEntityCollectionNewComentarioEntityToAttach.getClass(), comentarioEntityCollectionNewComentarioEntityToAttach.getId());
                attachedComentarioEntityCollectionNew.add(comentarioEntityCollectionNewComentarioEntityToAttach);
            }
            comentarioEntityCollectionNew = attachedComentarioEntityCollectionNew;
            usuarioEntity.setComentarioEntityCollection(comentarioEntityCollectionNew);
            usuarioEntity = em.merge(usuarioEntity);
            for (ObjetoEntity objetoEntityCollectionNewObjetoEntity : objetoEntityCollectionNew)
            {
                if (!objetoEntityCollectionOld.contains(objetoEntityCollectionNewObjetoEntity))
                {
                    UsuarioEntity oldUsuarioOfObjetoEntityCollectionNewObjetoEntity = objetoEntityCollectionNewObjetoEntity.getUsuario();
                    objetoEntityCollectionNewObjetoEntity.setUsuario(usuarioEntity);
                    objetoEntityCollectionNewObjetoEntity = em.merge(objetoEntityCollectionNewObjetoEntity);
                    if (oldUsuarioOfObjetoEntityCollectionNewObjetoEntity != null && !oldUsuarioOfObjetoEntityCollectionNewObjetoEntity.equals(usuarioEntity))
                    {
                        oldUsuarioOfObjetoEntityCollectionNewObjetoEntity.getObjetoEntityCollection().remove(objetoEntityCollectionNewObjetoEntity);
                        oldUsuarioOfObjetoEntityCollectionNewObjetoEntity = em.merge(oldUsuarioOfObjetoEntityCollectionNewObjetoEntity);
                    }
                }
            }
            for (ComentarioEntity comentarioEntityCollectionNewComentarioEntity : comentarioEntityCollectionNew)
            {
                if (!comentarioEntityCollectionOld.contains(comentarioEntityCollectionNewComentarioEntity))
                {
                    UsuarioEntity oldUsuarioOfComentarioEntityCollectionNewComentarioEntity = comentarioEntityCollectionNewComentarioEntity.getUsuario();
                    comentarioEntityCollectionNewComentarioEntity.setUsuario(usuarioEntity);
                    comentarioEntityCollectionNewComentarioEntity = em.merge(comentarioEntityCollectionNewComentarioEntity);
                    if (oldUsuarioOfComentarioEntityCollectionNewComentarioEntity != null && !oldUsuarioOfComentarioEntityCollectionNewComentarioEntity.equals(usuarioEntity))
                    {
                        oldUsuarioOfComentarioEntityCollectionNewComentarioEntity.getComentarioEntityCollection().remove(comentarioEntityCollectionNewComentarioEntity);
                        oldUsuarioOfComentarioEntityCollectionNewComentarioEntity = em.merge(oldUsuarioOfComentarioEntityCollectionNewComentarioEntity);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex)
        {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0)
            {
                Integer id = usuarioEntity.getId();
                if (findUsuarioEntity(id) == null)
                {
                    throw new NonexistentEntityException("The usuarioEntity with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally
        {
            if (em != null)
            {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException
    {
        EntityManager em = null;
        try
        {
            em = getEntityManager();
            em.getTransaction().begin();
            UsuarioEntity usuarioEntity;
            try
            {
                usuarioEntity = em.getReference(UsuarioEntity.class, id);
                usuarioEntity.getId();
            } catch (EntityNotFoundException enfe)
            {
                throw new NonexistentEntityException("The usuarioEntity with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<ObjetoEntity> objetoEntityCollectionOrphanCheck = usuarioEntity.getObjetoEntityCollection();
            for (ObjetoEntity objetoEntityCollectionOrphanCheckObjetoEntity : objetoEntityCollectionOrphanCheck)
            {
                if (illegalOrphanMessages == null)
                {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This UsuarioEntity (" + usuarioEntity + ") cannot be destroyed since the ObjetoEntity " + objetoEntityCollectionOrphanCheckObjetoEntity + " in its objetoEntityCollection field has a non-nullable usuario field.");
            }
            Collection<ComentarioEntity> comentarioEntityCollectionOrphanCheck = usuarioEntity.getComentarioEntityCollection();
            for (ComentarioEntity comentarioEntityCollectionOrphanCheckComentarioEntity : comentarioEntityCollectionOrphanCheck)
            {
                if (illegalOrphanMessages == null)
                {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This UsuarioEntity (" + usuarioEntity + ") cannot be destroyed since the ComentarioEntity " + comentarioEntityCollectionOrphanCheckComentarioEntity + " in its comentarioEntityCollection field has a non-nullable usuario field.");
            }
            if (illegalOrphanMessages != null)
            {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            em.remove(usuarioEntity);
            em.getTransaction().commit();
        } finally
        {
            if (em != null)
            {
                em.close();
            }
        }
    }

    public List<UsuarioEntity> findUsuarioEntityEntities()
    {
        return findUsuarioEntityEntities(true, -1, -1);
    }

    public List<UsuarioEntity> findUsuarioEntityEntities(int maxResults, int firstResult)
    {
        return findUsuarioEntityEntities(false, maxResults, firstResult);
    }

    private List<UsuarioEntity> findUsuarioEntityEntities(boolean all, int maxResults, int firstResult)
    {
        EntityManager em = getEntityManager();
        try
        {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(UsuarioEntity.class));
            Query q = em.createQuery(cq);
            if (!all)
            {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally
        {
            em.close();
        }
    }

    public UsuarioEntity findUsuarioEntity(Integer id)
    {
        EntityManager em = getEntityManager();
        try
        {
            return em.find(UsuarioEntity.class, id);
        } finally
        {
            em.close();
        }
    }

    public int getUsuarioEntityCount()
    {
        EntityManager em = getEntityManager();
        try
        {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<UsuarioEntity> rt = cq.from(UsuarioEntity.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally
        {
            em.close();
        }
    }
    
    public UsuarioEntity findUsuarioEntity(String nom, String pass) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("SELECT u FROM UsuarioEntity u WHERE u.nombreUsuario = :nombreUsuario AND u.pass = :passUsuario");
            q.setParameter("nombreUsuario", nom);
            q.setParameter("passUsuario", pass);
            
            UsuarioEntity aux = (UsuarioEntity) q.getSingleResult();
            if (aux.getPass().compareToIgnoreCase(pass) == 0) {
                return aux;
            }
            return null;
            
        }catch(Exception e){
            return null;
        }finally {
            em.close();
            
        }
    }
    
    
//    public UsuarioEntity findUsuarioEntity (String nom, String pass)
//    {
//         EntityManager em = getEntityManager();
//         try
//        {
//            Query q = em.createQuery("SELECT u FROM UsuarioEntity u WHERE u.nombreUsuario = :nombreUsuario AND u.pass = :passUsuario");
//            q.setParameter("nombreUsusario", nom);
//            q.setParameter("passUsuario", pass);
//            UsuarioEntity usuario = (UsuarioEntity) q.getSingleResult();
//            
//            return usuario;
//           
//        } catch (Exception e)
//        {
//            System.out.println(e);
//        }
//         finally    
//        {
//            em.close();
//        }
//         return null;
//    }
    
}
